﻿// 1008train01.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <limits>
#include <numeric>
#include <iomanip>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <deque>
#include <bitset>

using namespace std;

/*
最大响应时间有如下计算方式:
当 MaxRespCode < 128，MaxRespTime = MaxRespCode;
当 MaxRespCode ≥ 128，MaxRespTime = (mant | 0x10) << (exp + 3);
注：exp为最大响应时间的高5~7位；mant为最大响应时间的低4位
其中接收到的MaxRespCode 最大值为 255，以上出现所有字段均为无符号数

输入描述
第一行为查询报文个数C，后续每行分别为HOST 收到报文时间 T，及最大响应时间M，以空格分割

输出描述
HOST发送响应报文的时间

输入
3
0 20
1 10
8 20
输出
11

输入
2
0 255
200 60
输出
260

第0秒收到第1个报文，响应时间为255秒，
则要到(15 | 0x10) << (7 + 3) = 31744秒响应(mant = 15，exp =7)
第200秒收到第2个报文，响应时间为60秒，
则要到200+60 = 260秒响应，
与第上面的报文的响应时间比较获得响应时间最小为260秒
最终得到最小响应报文时间为260秒
 */
class Solution01
{
public:
    int getResNum(int num)
    {
        //MaxRespCode < 128
        if (num < 128) return num;
        //MaxRespCode ≥ 128
        string binary_str = bitset<32>(num).to_string();

        while (binary_str[0]=='0')
        {
            binary_str = binary_str.substr(1);
        }

        string mant_str = binary_str.substr(0, 4);
        string exp_str = binary_str.substr(5, 3);

        bitset<32>bs_mant(mant_str);
        uint32_t mant = bs_mant.to_ulong();

        bitset<32>bs_exp(exp_str);
        uint32_t exp = bs_exp.to_ulong();

        return (mant | 0x10) << (exp + 3);
	    //
    }

    Solution01(vector<vector<int>>&num_vec)
    {
        //MaxRespCode ≥ 128，MaxRespTime = (mant | 0x10) << (exp + 3)
		//exp为最大响应时间的高5~7位；mant为最大响应时间的低4位
        int result = INT_MAX;
        for (auto&item:num_vec)
        {
            int start = item[0];
            int time = getResNum(item[1]);
            int end = start + time;
            result = min(end, result);
        }

        cout << result;
	    //solu
    }
};


/*
 小船给小扇一个正整数n (1 <= n <= 1e9)，小扇需要找到一个比n大的数字m，
 使得m和n对应的二进制中1的个数要相同
 （如4对应二进制100，8对应二进制1000，1的个数都为1），
 现在求m的最小值

输入
300
输出
305
 */
class Solution02
{
public:
    Solution02(int origin)
    {
        //从右到左，连续0(cnt0)+连续1(cnt1)+最高位
        //最高位改成1，最末尾改成cnt1-1个1
        string binary_origin = bitset<64>(origin).to_string();
        while (binary_origin[0]=='0')
        {
            binary_origin = binary_origin.substr(1);
        }
        string exec_str = binary_origin;
        cout << exec_str;
        reverse(exec_str.begin(), exec_str.end());
        int count_0 = 0, count_1 = 0;
        bool is_left = true;
        int exec_size = exec_str.size();
        for (int i=0; i<exec_size; i++)
        {
	        if (exec_str[i]=='0' && is_left)
	        {
                count_0 += 1;
	        }
            if (exec_str[i]=='1')
            {
                is_left = false;
                count_1 += 1;
                if (i + 1 < exec_size && exec_str[i + 1] == '0')
                    break;
            }
        }

        
        if (count_0+count_1==exec_size)
        {
            if (count_1 == 1)
            {
                reverse(exec_str.begin(), exec_str.end());
                exec_str += '0';
            }
            else
            {
				//1110 
				//10011
                for (auto& ch : exec_str)
                {
                    ch = '0';
                }
                exec_str += '1';

                for (int i=0; i<count_1-1; i++)
                {
                    exec_str[i] = '1';
                }
                reverse(exec_str.begin(), exec_str.end());
                //
            }
	        //
        }
        else if (count_0 + count_1 < exec_size)
        {
            int high = count_0 + count_1;
            exec_str[high] = '1';

            for (int i=0; i<high; i++)
            {
                exec_str[i] = '0';
            }

            int remain = count_1 - 1;
            for (int i=0; i<remain; i++)
            {
                exec_str[i] = '1';
            }
            reverse(exec_str.begin(), exec_str.end());
            //
        }
        
        uint64_t result = bitset<64>(exec_str).to_ulong();
        cout << result;
	    //solu
    }
};


/*
 输入描述
第一行有一个正整数 N；其中 1 ≤ N ≤ 1000000。
第二行有一个长为 N 的二进制数，表示与电路的第一个输入数，即会发生比特交换的输入数。
第三行有一个长为 N 的二进制数，表示与电路的第二个输入数。注意第二个输入数不会发生比特交换。

输出描述
输出只有一个整数，表示会影响或结果的交换方案个数。

输入
3
010
110
输出
1
 */
class Solution03
{
public:
    Solution03(int size, string&binary_1, string&binary_2)
    {
        int count_11 = 0, count_00 = 0, count_01 = 0, count_10 = 0;

        for (int i=0; i<size; i++)
        {
            char ch_1 = binary_1[i];
            char ch_2 = binary_2[i];

            if (ch_1 == '1' && ch_2 == '1') count_11 += 1;
            if (ch_1 == '0' && ch_2 == '0') count_00 += 1;
            if (ch_1 == '1' && ch_2 == '0') count_10 += 1;
            if (ch_1 == '0' && ch_2 == '1') count_01 += 1;
        }

        //binary_1的i和j必须，一个是0，一个是1
        //binary_2对应位置，至少一个0
        int res1 = count_11 * count_00;
        int res2 = count_10 * count_00;
        int res3 = count_10 * count_01;

        cout << res1 + res2 + res3;
	    //solu
    }
};


int main()
{
	{
        int size;
        cin >> size;

        string binary_1, binary_2;
        cin >> binary_1 >> binary_2;

        Solution03 solu(size, binary_1, binary_2);

        return 0;
	}
	{
        int origin;
        cin >> origin;

        Solution02 solu(origin);
        return 0;
	}
    int v_size;
    cin >> v_size;
    vector<vector<int>>num_vec(v_size, vector<int>(2));

    for (int i=0; i<v_size; i++)
    {
        cin >> num_vec[i][0] >> num_vec[i][1];
    }

    Solution01 solu(num_vec);

    return 0;
}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
